home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / OTHERCST / JPSRC_FO / JPEGDATA.H < prev    next >
Text File  |  1991-10-13  |  34KB  |  813 lines
  1. /*
  2.  * jpegdata.h
  3.  *
  4.  * Copyright (C) 1991, Thomas G. Lane.
  5.  * This file is part of the Independent JPEG Group's software.
  6.  * For conditions of distribution and use, see the accompanying README file.
  7.  *
  8.  * This file defines shared data structures for the various JPEG modules.
  9.  */
  10.  
  11.  
  12. /*
  13.  * You might need to change some of the following declarations if you are
  14.  * using the JPEG software within a surrounding application program
  15.  * or porting it to an unusual system.
  16.  */
  17.  
  18.  
  19. /* If the source or destination of image data is not to be stdio streams,
  20.  * these types may need work.  You can replace them with some kind of
  21.  * pointer or indicator that is useful to you, or just ignore 'em.
  22.  * Note that the user interface and the various jrdxxx/jwrxxx modules
  23.  * will also need work for non-stdio input/output.
  24.  */
  25.  
  26. typedef FILE * JFILEREF;    /* source or dest of JPEG-compressed data */
  27.  
  28. typedef FILE * IFILEREF;    /* source or dest of non-JPEG image data */
  29.  
  30.  
  31. /* These defines are used in all function definitions and extern declarations.
  32.  * You could modify them if you need to change function linkage conventions,
  33.  * as is shown below for use with C++.  Another application would be to make
  34.  * all functions global for use with code profilers that require it.
  35.  * NOTE: the C++ test does the right thing if you are reading this include
  36.  * file in a C++ application to link to JPEG code that's been compiled with a
  37.  * regular C compiler.  I'm not sure it works if you try to compile the JPEG
  38.  * code with C++.
  39.  */
  40.  
  41. #define METHODDEF static    /* a function called through method pointers */
  42. #define LOCAL      static    /* a function used only in its module */
  43. #define GLOBAL            /* a function referenced thru EXTERNs */
  44. #ifdef __cplusplus
  45. #define EXTERN      extern "C"    /* a reference to a GLOBAL function */
  46. #else
  47. #define EXTERN      extern    /* a reference to a GLOBAL function */
  48. #endif
  49.  
  50.  
  51. /* Here is the pseudo-keyword for declaring pointers that must be "far"
  52.  * on 80x86 machines.  Most of the specialized coding for 80x86 is handled
  53.  * by just saying "FAR *" where such a pointer is needed.  In a few places
  54.  * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
  55.  */
  56.  
  57. #ifdef NEED_FAR_POINTERS
  58. #define FAR  far
  59. #else
  60. #define FAR
  61. #endif
  62.  
  63.  
  64.  
  65. /* The remaining declarations are not system-dependent, we hope. */
  66.  
  67.  
  68. /*
  69.  * NOTE: if you have an ancient, strict-K&R C compiler, it may choke on the
  70.  * similarly-named fields in compress_info_struct and decompress_info_struct.
  71.  * If this happens, you can get around it by rearranging the two structs so
  72.  * that the similarly-named fields appear first and in the same order in
  73.  * each struct.  Since such compilers are now pretty rare, we haven't done
  74.  * this in the portable code, preferring to maintain a logical ordering.
  75.  */
  76.  
  77.  
  78.  
  79. /* This macro is used to declare a "method", that is, a function pointer. */
  80. /* We want to supply prototype parameters if the compiler can cope. */
  81. /* Note that the arglist parameter must be parenthesized! */
  82.  
  83. #ifdef PROTO
  84. #define METHOD(type,methodname,arglist)  type (*methodname) arglist
  85. #else
  86. #define METHOD(type,methodname,arglist)  type (*methodname) ()
  87. #endif
  88.  
  89. /* Forward references to lists of method pointers */
  90. typedef struct external_methods_struct * external_methods_ptr;
  91. typedef struct compress_methods_struct * compress_methods_ptr;
  92. typedef struct decompress_methods_struct * decompress_methods_ptr;
  93.  
  94.  
  95. /* Data structures for images containing either samples or coefficients. */
  96. /* Note that the topmost (leftmost) index is always color component. */
  97. /* On 80x86 machines, the image arrays are too big for near pointers, */
  98. /* but the pointer arrays can fit in near memory. */
  99.  
  100. typedef JSAMPLE FAR *JSAMPROW;    /* ptr to one image row of pixel samples. */
  101. typedef JSAMPROW *JSAMPARRAY;    /* ptr to some rows (a 2-D sample array) */
  102. typedef JSAMPARRAY *JSAMPIMAGE;    /* a 3-D sample array: top index is color */
  103.  
  104.  
  105. #define DCTSIZE        8    /* The basic DCT block is 8x8 samples */
  106. #define DCTSIZE2    64    /* DCTSIZE squared; # of elements in a block */
  107.  
  108. typedef JCOEF JBLOCK[DCTSIZE2];    /* one block of coefficients */
  109. typedef JBLOCK FAR *JBLOCKROW;    /* pointer to one row of coefficient blocks */
  110. typedef JBLOCKROW *JBLOCKARRAY;        /* a 2-D array of coefficient blocks */
  111. typedef JBLOCKARRAY *JBLOCKIMAGE;    /* a 3-D array of coefficient blocks */
  112.  
  113. typedef JCOEF FAR *JCOEFPTR;    /* useful in a couple of places */
  114.  
  115.  
  116. /* The input and output data of the DCT transform subroutines are of
  117.  * the following type, which need not be the same as JCOEF.
  118.  * For example, on a machine with fast floating point, it might make sense
  119.  * to recode the DCT routines to use floating point; then DCTELEM would be
  120.  * 'float' or 'double'.
  121.  */
  122.  
  123. typedef JCOEF DCTELEM;
  124. typedef DCTELEM DCTBLOCK[DCTSIZE2];
  125.  
  126.  
  127. /* Types for JPEG compression parameters and working tables. */
  128.  
  129.  
  130. typedef enum {            /* defines known color spaces */
  131.     CS_UNKNOWN,        /* error/unspecified */
  132.     CS_GRAYSCALE,        /* monochrome (only 1 component) */
  133.     CS_RGB,            /* red/green/blue */
  134.     CS_YCbCr,        /* Y/Cb/Cr (also known as YUV) */
  135.     CS_YIQ,            /* Y/I/Q */
  136.     CS_CMYK            /* C/M/Y/K */
  137. } COLOR_SPACE;
  138.  
  139.  
  140. typedef struct {        /* Basic info about one component */
  141.   /* These values are fixed over the whole image */
  142.   /* For compression, they must be supplied by the user interface; */
  143.   /* for decompression, they are read from the SOF marker. */
  144.     short component_id;    /* identifier for this component (0..255) */
  145.     short component_index;    /* its index in SOF or cinfo->comp_info[] */
  146.     short h_samp_factor;    /* horizontal sampling factor (1..4) */
  147.     short v_samp_factor;    /* vertical sampling factor (1..4) */
  148.     short quant_tbl_no;    /* quantization table selector (0..3) */
  149.   /* These values may vary between scans */
  150.   /* For compression, they must be supplied by the user interface; */
  151.   /* for decompression, they are read from the SOS marker. */
  152.     short dc_tbl_no;    /* DC entropy table selector (0..3) */
  153.     short ac_tbl_no;    /* AC entropy table selector (0..3) */
  154.   /* These values are computed during compression or decompression startup */
  155.     long true_comp_width;    /* component's image width in samples */
  156.     long true_comp_height;    /* component's image height in samples */
  157.     /* the above are the logical dimensions of the subsampled image */
  158.   /* These values are computed before starting a scan of the component */
  159.     short MCU_width;    /* number of blocks per MCU, horizontally */
  160.     short MCU_height;    /* number of blocks per MCU, vertically */
  161.     short MCU_blocks;    /* MCU_width * MCU_height */
  162.     long subsampled_width;    /* image width in samples, after expansion */
  163.     long subsampled_height;    /* image height in samples, after expansion */
  164.     /* the above are the true_comp_xxx values rounded up to multiples of */
  165.     /* the MCU dimensions; these are the working dimensions of the array */
  166.     /* as it is passed through the DCT or IDCT step.  NOTE: these values */
  167.     /* differ depending on whether the component is interleaved or not!! */
  168. } jpeg_component_info;
  169.  
  170.  
  171. /* DCT coefficient quantization tables.
  172.  * For 8-bit precision, 'INT16' should be good enough for quantization values;
  173.  * for more precision, we go for the full 16 bits.  'INT16' provides a useful
  174.  * speedup on many machines (multiplication & division of JCOEFs by
  175.  * quantization values is a significant chunk of the runtime).
  176.  * Note: the values in a QUANT_TBL are always given in zigzag order.
  177.  */
  178. #ifdef EIGHT_BIT_SAMPLES
  179. typedef INT16 QUANT_VAL;    /* element of a quantization table */
  180. #else
  181. typedef UINT16 QUANT_VAL;    /* element of a quantization table */
  182. #endif
  183. typedef QUANT_VAL QUANT_TBL[DCTSIZE2];    /* A quantization table */
  184. typedef QUANT_VAL * QUANT_TBL_PTR;    /* pointer to same */
  185.  
  186.  
  187. typedef struct {        /* A Huffman coding table */
  188.   /* These two fields directly represent the contents of a JPEG DHT marker */
  189.     UINT8 bits[17];        /* bits[k] = # of symbols with codes of */
  190.                 /* length k bits; bits[0] is unused */
  191.     UINT8 huffval[256];    /* The symbols, in order of incr code length */
  192.   /* This field is used only during compression.  It's initialized FALSE when
  193.    * the table is created, and set TRUE when it's been output to the file.
  194.    */
  195.     boolean sent_table;    /* TRUE when table has been output */
  196.   /* The remaining fields are computed from the above to allow more efficient
  197.    * coding and decoding.  These fields should be considered private to the
  198.    * Huffman compression & decompression modules.
  199.    */
  200.     UINT16 ehufco[256];    /* code for each symbol */
  201.     char ehufsi[256];    /* length of code for each symbol */
  202.     UINT16 mincode[17];    /* smallest code of length k */
  203.     INT32 maxcode[17];    /* largest code of length k (-1 if none) */
  204.     short valptr[17];    /* huffval[] index of 1st symbol of length k */
  205. } HUFF_TBL;
  206.  
  207.  
  208. #define NUM_QUANT_TBLS      4    /* quantization tables are numbered 0..3 */
  209. #define NUM_HUFF_TBLS       4    /* Huffman tables are numbered 0..3 */
  210. #define NUM_ARITH_TBLS      16    /* arith-coding tables are numbered 0..15 */
  211. #define MAX_COMPS_IN_SCAN   4    /* JPEG limit on # of components in one scan */
  212. #define MAX_SAMP_FACTOR     4    /* JPEG limit on sampling factors */
  213. #define MAX_BLOCKS_IN_MCU   10    /* JPEG limit on # of blocks in an MCU */
  214.  
  215.  
  216. /* Working data for compression */
  217.  
  218. struct compress_info_struct {
  219. /*
  220.  * All of these fields shall be established by the user interface before
  221.  * calling jpeg_compress, or by the input_init or c_ui_method_selection
  222.  * methods.
  223.  * Most parameters can be set to reasonable defaults by j_default_compression.
  224.  * Note that the UI must supply the storage for the main methods struct,
  225.  * though it sets only a few of the methods there.
  226.  */
  227.     compress_methods_ptr methods; /* Points to list of methods to use */
  228.  
  229.     external_methods_ptr emethods; /* Points to list of methods to use */
  230.  
  231.     IFILEREF input_file;    /* tells input routines where to read image */
  232.     JFILEREF output_file;    /* tells output routines where to write JPEG */
  233.  
  234.     long image_width;    /* input image width */
  235.     long image_height;    /* input image height */
  236.     short input_components;    /* # of color components in input image */
  237.  
  238.     short data_precision;    /* bits of precision in image data */
  239.  
  240.     COLOR_SPACE in_color_space; /* colorspace of input file */
  241.     COLOR_SPACE jpeg_color_space; /* colorspace of JPEG file */
  242.  
  243.     double input_gamma;    /* image gamma of input file */
  244.  
  245.     boolean write_JFIF_header; /* should a JFIF marker be written? */
  246.     /* These three values are not used by the JPEG code, only copied */
  247.     /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
  248.     /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
  249.     /* ratio is defined by X_density/Y_density even when density_unit=0. */
  250.     UINT8 density_unit;    /* JFIF code for pixel size units */
  251.     UINT16 X_density;    /* Horizontal pixel density */
  252.     UINT16 Y_density;    /* Vertical pixel density */
  253.  
  254.     short num_components;    /* # of color components in JPEG image */
  255.     jpeg_component_info * comp_info;
  256.     /* comp_info[i] describes component that appears i'th in SOF */
  257.  
  258.     QUANT_TBL_PTR quant_tbl_ptrs[NUM_QUANT_TBLS];
  259.     /* ptrs to coefficient quantization tables, or NULL if not defined */
  260.  
  261.     HUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
  262.     HUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
  263.     /* ptrs to Huffman coding tables, or NULL if not defined */
  264.  
  265.     UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arithmetic-coding tables */
  266.     UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arithmetic-coding tables */
  267.     UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arithmetic-coding tables */
  268.  
  269.     boolean arith_code;    /* TRUE=arithmetic coding, FALSE=Huffman */
  270.     boolean interleave;    /* TRUE=interleaved output, FALSE=not */
  271.     boolean optimize_coding; /* TRUE=optimize entropy encoding parms */
  272.     boolean CCIR601_sampling; /* TRUE=first samples are cosited */
  273.  
  274.     UINT16 restart_interval;/* MDUs per restart interval, or 0 for no restart */
  275.  
  276. /*
  277.  * These fields are computed during jpeg_compress startup
  278.  */
  279.     short max_h_samp_factor; /* largest h_samp_factor */
  280.     short max_v_samp_factor; /* largest v_samp_factor */
  281.  
  282. /*
  283.  * These fields are valid during any one scan
  284.  */
  285.     short comps_in_scan;    /* # of JPEG components output this time */
  286.     jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
  287.     /* *cur_comp_info[i] describes component that appears i'th in SOS */
  288.  
  289.     long MCUs_per_row;    /* # of MCUs across the image */
  290.     long MCU_rows_in_scan;    /* # of MCU rows in the image */
  291.  
  292.     short blocks_in_MCU;    /* # of DCT blocks per MCU */
  293.     short MCU_membership[MAX_BLOCKS_IN_MCU];
  294.     /* MCU_membership[i] is index in cur_comp_info of component owning */
  295.     /* i'th block in an MCU */
  296.  
  297.     /* these fields are private data for the entropy encoder */
  298.     JCOEF last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each comp */
  299.     JCOEF last_dc_diff[MAX_COMPS_IN_SCAN]; /* last DC diff for each comp */
  300.     UINT16 restarts_to_go;    /* MDUs left in this restart interval */
  301.     short next_restart_num;    /* # of next RSTn marker (0..7) */
  302. };
  303.  
  304. typedef struct compress_info_struct * compress_info_ptr;
  305.  
  306.  
  307. /* Working data for decompression */
  308.  
  309. struct decompress_info_struct {
  310. /*
  311.  * These fields shall be established by the user interface before
  312.  * calling jpeg_decompress.  Note that the UI must supply the storage for
  313.  * the main methods struct, though it sets only a few of the methods there.
  314.  */
  315.     decompress_methods_ptr methods; /* Points to list of methods to use */
  316.  
  317.     external_methods_ptr emethods; /* Points to list of methods to use */
  318.  
  319.     JFILEREF input_file;    /* tells input routines where to read JPEG */
  320.     IFILEREF output_file;    /* tells output routines where to write image */
  321.  
  322.     /* these can be set at d_ui_method_selection time: */
  323.  
  324.     COLOR_SPACE out_color_space; /* colorspace of output */
  325.  
  326.     double output_gamma;    /* image gamma wanted in output */
  327.  
  328.     boolean quantize_colors; /* T if output is a colormapped format */
  329.     /* the following are ignored if not quantize_colors: */
  330.     boolean two_pass_quantize;    /* use two-pass color quantization? */
  331.     boolean use_dithering;        /* want color dithering? */
  332.     int desired_number_of_colors;    /* number of colors to use */
  333.  
  334.     boolean do_block_smoothing; /* T = apply cross-block smoothing */
  335.     boolean do_pixel_smoothing; /* T = apply post-subsampling smoothing */
  336.  
  337. /*
  338.  * These fields are used for efficient buffering of data between read_jpeg_data
  339.  * and the entropy decoding object.  By using a shared buffer, we avoid copying
  340.  * data and eliminate the need for an "unget" operation at the end of a scan.
  341.  * The actual source of the data is known only to read_jpeg_data; see the
  342.  * JGETC macro, below.
  343.  * Note: the user interface is expected to allocate the input_buffer and
  344.  * initialize bytes_in_buffer to 0.  Also, for JFIF/raw-JPEG input, the UI
  345.  * actually supplies the read_jpeg_data method.
  346.  */
  347.     char * input_buffer;    /* start of buffer (private to input code) */
  348.     char * next_input_byte;    /* => next byte to read from buffer */
  349.     int bytes_in_buffer;    /* # of bytes remaining in buffer */
  350.  
  351. /*
  352.  * These fields are set by read_file_header or read_scan_header
  353.  */
  354.     long image_width;    /* overall image width */
  355.     long image_height;    /* overall image height */
  356.  
  357.     short data_precision;    /* bits of precision in image data */
  358.  
  359.     COLOR_SPACE jpeg_color_space; /* colorspace of JPEG file */
  360.  
  361.         /* These three values are not used by the JPEG code, merely copied */
  362.     /* from the JFIF APP0 marker (if any). */
  363.     UINT8 density_unit;    /* JFIF code for pixel size units */
  364.     UINT16 X_density;    /* Horizontal pixel density */
  365.     UINT16 Y_density;    /* Vertical pixel density */
  366.  
  367.     short num_components;    /* # of color components in JPEG image */
  368.     jpeg_component_info * comp_info;
  369.     /* comp_info[i] describes component that appears i'th in SOF */
  370.  
  371.     QUANT_TBL_PTR quant_tbl_ptrs[NUM_QUANT_TBLS];
  372.     /* ptrs to coefficient quantization tables, or NULL if not defined */
  373.  
  374.     HUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
  375.     HUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
  376.     /* ptrs to Huffman coding tables, or NULL if not defined */
  377.  
  378.     UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
  379.     UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
  380.     UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
  381.  
  382.     boolean arith_code;    /* TRUE=arithmetic coding, FALSE=Huffman */
  383.     boolean CCIR601_sampling; /* TRUE=first samples are cosited */
  384.  
  385.     UINT16 restart_interval;/* MDUs per restart interval, or 0 for no restart */
  386.  
  387. /*
  388.  * These fields are computed during jpeg_decompress startup
  389.  */
  390.     short max_h_samp_factor; /* largest h_samp_factor */
  391.     short max_v_samp_factor; /* largest v_samp_factor */
  392.  
  393.     short color_out_comps;    /* # of color components output by color_convert */
  394.                 /* (need not match num_components) */
  395.     short final_out_comps;    /* # of color components in output image */
  396.     /* (1 when quantizing colors, else same as color_out_comps) */
  397.  
  398. /*
  399.  * These fields are valid during any one scan
  400.  */
  401.     short comps_in_scan;    /* # of JPEG components input this time */
  402.     jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
  403.     /* *cur_comp_info[i] describes component that appears i'th in SOS */
  404.  
  405.     long MCUs_per_row;    /* # of MCUs across the image */
  406.     long MCU_rows_in_scan;    /* # of MCU rows in the image */
  407.  
  408.     short blocks_in_MCU;    /* # of DCT blocks per MCU */
  409.     short MCU_membership[MAX_BLOCKS_IN_MCU];
  410.     /* MCU_membership[i] is index in cur_comp_info of component owning */
  411.     /* i'th block in an MCU */
  412.  
  413.     /* these fields are private data for the entropy encoder */
  414.     JCOEF last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each comp */
  415.     JCOEF last_dc_diff[MAX_COMPS_IN_SCAN]; /* last DC diff for each comp */
  416.     UINT16 restarts_to_go;    /* MDUs left in this restart interval */
  417.     short next_restart_num;    /* # of next RSTn marker (0..7) */
  418. };
  419.  
  420. typedef struct decompress_info_struct * decompress_info_ptr;
  421.  
  422.  
  423. /* Macros for reading data from the decompression input buffer */
  424.  
  425. #ifdef CHAR_IS_UNSIGNED
  426. #define JGETC(cinfo)    ( --(cinfo)->bytes_in_buffer < 0 ? \
  427.              (*(cinfo)->methods->read_jpeg_data) (cinfo) : \
  428.              (int) *(cinfo)->next_input_byte++ )
  429. #else
  430. #define JGETC(cinfo)    ( --(cinfo)->bytes_in_buffer < 0 ? \
  431.              (*(cinfo)->methods->read_jpeg_data) (cinfo) : \
  432.              (int) (*(cinfo)->next_input_byte++) & 0xFF )
  433. #endif
  434.  
  435. #define JUNGETC(ch,cinfo)  ((cinfo)->bytes_in_buffer++, \
  436.                 *(--((cinfo)->next_input_byte)) = (ch))
  437.  
  438. #define MIN_UNGET    2    /* may always do at least 2 JUNGETCs */
  439.  
  440.  
  441. /* A virtual image has a control block whose contents are private to the
  442.  * memory manager module (and may differ between managers).  The rest of the
  443.  * code only refers to virtual images by these pointer types.
  444.  */
  445.  
  446. typedef struct big_sarray_control * big_sarray_ptr;
  447. typedef struct big_barray_control * big_barray_ptr;
  448.  
  449.  
  450. /* Method types that need typedefs */
  451.  
  452. typedef METHOD(void, MCU_output_method_ptr, (compress_info_ptr cinfo,
  453.                          JBLOCK *MCU_data));
  454. typedef METHOD(void, MCU_output_caller_ptr, (compress_info_ptr cinfo,
  455.                          MCU_output_method_ptr output_method));
  456. typedef METHOD(void, subsample_ptr, (compress_info_ptr cinfo,
  457.                      int which_component,
  458.                      long input_cols, int input_rows,
  459.                      long output_cols, int output_rows,
  460.                      JSAMPARRAY above,
  461.                      JSAMPARRAY input_data,
  462.                      JSAMPARRAY below,
  463.                      JSAMPARRAY output_data));
  464. typedef METHOD(void, unsubsample_ptr, (decompress_info_ptr cinfo,
  465.                        int which_component,
  466.                        long input_cols, int input_rows,
  467.                        long output_cols, int output_rows,
  468.                        JSAMPARRAY above,
  469.                        JSAMPARRAY input_data,
  470.                        JSAMPARRAY below,
  471.                        JSAMPARRAY output_data));
  472. typedef METHOD(void, quantize_method_ptr, (decompress_info_ptr cinfo,
  473.                        int num_rows,
  474.                        JSAMPIMAGE input_data,
  475.                        JSAMPARRAY output_workspace));
  476. typedef METHOD(void, quantize_caller_ptr, (decompress_info_ptr cinfo,
  477.                        quantize_method_ptr quantize_method));
  478.  
  479.  
  480. /* These structs contain function pointers for the various JPEG methods. */
  481.  
  482. /* Routines to be provided by the surrounding application, rather than the
  483.  * portable JPEG code proper.  These are the same for compression and
  484.  * decompression.
  485.  */
  486.  
  487. struct external_methods_struct {
  488.     /* User interface: error exit and trace message routines */
  489.     /* NOTE: the string msgtext parameters will eventually be replaced */
  490.     /* by an enumerated-type code so that non-English error messages */
  491.     /* can be substituted easily.  This will not be done until all the */
  492.     /* code is in place, so that we know what messages are needed. */
  493.     METHOD(void, error_exit, (char *msgtext));
  494.     METHOD(void, trace_message, (char *msgtext));
  495.  
  496.     /* Working data for error/trace facility */
  497.     /* See macros below for the usage of these variables */
  498.     int trace_level;    /* level of detail of tracing messages */
  499.     /* Use level 0 for unsuppressable messages (nonfatal errors) */
  500.     /* Use levels 1, 2, 3 for successively more detailed trace options */
  501.  
  502.     int message_parm[8];    /* store numeric parms for messages here */
  503.  
  504.     /* Memory management */
  505.     /* NB: alloc routines never return NULL. They exit to */
  506.     /* error_exit if not successful. */
  507.     METHOD(void *, alloc_small, (size_t sizeofobject));
  508.     METHOD(void, free_small, (void *ptr));
  509. #ifdef NEED_FAR_POINTERS    /* routines for getting far-heap space */
  510.     METHOD(void FAR *, alloc_medium, (size_t sizeofobject));
  511.     METHOD(void, free_medium, (void FAR *ptr));
  512. #else
  513. #define alloc_medium alloc_small
  514. #define free_medium  free_small
  515. #endif
  516.     METHOD(JSAMPARRAY, alloc_small_sarray, (long samplesperrow,
  517.                         long numrows));
  518.     METHOD(void, free_small_sarray, (JSAMPARRAY ptr,
  519.                      long numrows));
  520.     METHOD(JBLOCKARRAY, alloc_small_barray, (long blocksperrow,
  521.                          long numrows));
  522.     METHOD(void, free_small_barray, (JBLOCKARRAY ptr,
  523.                      long numrows));
  524.     METHOD(big_sarray_ptr, request_big_sarray, (long samplesperrow,
  525.                             long numrows,
  526.                             long unitheight));
  527.     METHOD(big_barray_ptr, request_big_barray, (long blocksperrow,
  528.                             long numrows,
  529.                             long unitheight));
  530.     METHOD(void, alloc_big_arrays, (long extra_small_samples,
  531.                     long extra_small_blocks,
  532.                     long extra_medium_space));
  533.     METHOD(JSAMPARRAY, access_big_sarray, (big_sarray_ptr ptr,
  534.                            long start_row,
  535.                            boolean writable));
  536.     METHOD(JBLOCKARRAY, access_big_barray, (big_barray_ptr ptr,
  537.                         long start_row,
  538.                         boolean writable));
  539.     METHOD(void, free_big_sarray, (big_sarray_ptr ptr));
  540.     METHOD(void, free_big_barray, (big_barray_ptr ptr));
  541. };
  542.  
  543. /* Macros to simplify using the error and trace message stuff */
  544. /* The first parameter is generally cinfo->emethods */
  545.  
  546. #define ERREXIT(emeth,msg)        ((*(emeth)->error_exit) (msg))
  547. #define ERREXIT1(emeth,msg,p1)        ((emeth)->message_parm[0] = (p1), \
  548.                      (*(emeth)->error_exit) (msg))
  549. #define ERREXIT2(emeth,msg,p1,p2)    ((emeth)->message_parm[0] = (p1), \
  550.                      (emeth)->message_parm[1] = (p2), \
  551.                      (*(emeth)->error_exit) (msg))
  552. #define ERREXIT3(emeth,msg,p1,p2,p3)    ((emeth)->message_parm[0] = (p1), \
  553.                      (emeth)->message_parm[1] = (p2), \
  554.                      (emeth)->message_parm[2] = (p3), \
  555.                      (*(emeth)->error_exit) (msg))
  556. #define ERREXIT4(emeth,msg,p1,p2,p3,p4) ((emeth)->message_parm[0] = (p1), \
  557.                      (emeth)->message_parm[1] = (p2), \
  558.                      (emeth)->message_parm[2] = (p3), \
  559.                      (emeth)->message_parm[3] = (p4), \
  560.                      (*(emeth)->error_exit) (msg))
  561.  
  562. #define TRACEMS(emeth,lvl,msg)    \
  563.   ( (emeth)->trace_level >= (lvl) ? \
  564.    ((*(emeth)->trace_message) (msg), 0) : 0)
  565. #define TRACEMS1(emeth,lvl,msg,p1)    \
  566.   ( (emeth)->trace_level >= (lvl) ? \
  567.    ((emeth)->message_parm[0] = (p1), \
  568.     (*(emeth)->trace_message) (msg), 0) : 0)
  569. #define TRACEMS2(emeth,lvl,msg,p1,p2)    \
  570.   ( (emeth)->trace_level >= (lvl) ? \
  571.    ((emeth)->message_parm[0] = (p1), \
  572.     (emeth)->message_parm[1] = (p2), \
  573.     (*(emeth)->trace_message) (msg), 0) : 0)
  574. #define TRACEMS3(emeth,lvl,msg,p1,p2,p3)    \
  575.   ( (emeth)->trace_level >= (lvl) ? \
  576.    ((emeth)->message_parm[0] = (p1), \
  577.     (emeth)->message_parm[1] = (p2), \
  578.     (emeth)->message_parm[2] = (p3), \
  579.     (*(emeth)->trace_message) (msg), 0) : 0)
  580. #define TRACEMS4(emeth,lvl,msg,p1,p2,p3,p4)    \
  581.   ( (emeth)->trace_level >= (lvl) ? \
  582.    ((emeth)->message_parm[0] = (p1), \
  583.     (emeth)->message_parm[1] = (p2), \
  584.     (emeth)->message_parm[2] = (p3), \
  585.     (emeth)->message_parm[3] = (p4), \
  586.     (*(emeth)->trace_message) (msg), 0) : 0)
  587. #define TRACEMS8(emeth,lvl,msg,p1,p2,p3,p4,p5,p6,p7,p8)    \
  588.   ( (emeth)->trace_level >= (lvl) ? \
  589.    ((emeth)->message_parm[0] = (p1), \
  590.     (emeth)->message_parm[1] = (p2), \
  591.     (emeth)->message_parm[2] = (p3), \
  592.     (emeth)->message_parm[3] = (p4), \
  593.     (emeth)->message_parm[4] = (p5), \
  594.     (emeth)->message_parm[5] = (p6), \
  595.     (emeth)->message_parm[6] = (p7), \
  596.     (emeth)->message_parm[7] = (p8), \
  597.     (*(emeth)->trace_message) (msg), 0) : 0)
  598.  
  599.  
  600. /* Methods used during JPEG compression. */
  601.  
  602. struct compress_methods_struct {
  603.     /* Hook for user interface to get control after input_init */
  604.     METHOD(void, c_ui_method_selection, (compress_info_ptr cinfo));
  605.     /* Input image reading & conversion to standard form */
  606.     METHOD(void, input_init, (compress_info_ptr cinfo));
  607.     METHOD(void, get_input_row, (compress_info_ptr cinfo,
  608.                      JSAMPARRAY pixel_row));
  609.     METHOD(void, input_term, (compress_info_ptr cinfo));
  610.     /* Gamma and color space conversion */
  611.     METHOD(void, colorin_init, (compress_info_ptr cinfo));
  612.     METHOD(void, get_sample_rows, (compress_info_ptr cinfo,
  613.                        int rows_to_read,
  614.                        JSAMPIMAGE image_data));
  615.     METHOD(void, colorin_term, (compress_info_ptr cinfo));
  616.     /* Expand picture data at edges */
  617.     METHOD(void, edge_expand, (compress_info_ptr cinfo,
  618.                    long input_cols, int input_rows,
  619.                    long output_cols, int output_rows,
  620.                    JSAMPIMAGE image_data));
  621.     /* Subsample pixel values of a single component */
  622.     /* There can be a different subsample method for each component */
  623.     METHOD(void, subsample_init, (compress_info_ptr cinfo));
  624.     subsample_ptr subsample[MAX_COMPS_IN_SCAN];
  625.     METHOD(void, subsample_term, (compress_info_ptr cinfo));
  626.     /* Extract samples in MCU order, process & hand off to output_method */
  627.     /* The input is always exactly N MCU rows worth of data */
  628.     METHOD(void, extract_init, (compress_info_ptr cinfo));
  629.     METHOD(void, extract_MCUs, (compress_info_ptr cinfo,
  630.                     JSAMPIMAGE image_data,
  631.                     int num_mcu_rows,
  632.                     MCU_output_method_ptr output_method));
  633.     METHOD(void, extract_term, (compress_info_ptr cinfo));
  634.     /* Entropy encoding parameter optimization */
  635.     METHOD(void, entropy_optimize, (compress_info_ptr cinfo,
  636.                     MCU_output_caller_ptr source_method));
  637.     /* Entropy encoding */
  638.     METHOD(void, entropy_encoder_init, (compress_info_ptr cinfo));
  639.     METHOD(void, entropy_encode, (compress_info_ptr cinfo,
  640.                       JBLOCK *MCU_data));
  641.     METHOD(void, entropy_encoder_term, (compress_info_ptr cinfo));
  642.     /* JPEG file header construction */
  643.     METHOD(void, write_file_header, (compress_info_ptr cinfo));
  644.     METHOD(void, write_scan_header, (compress_info_ptr cinfo));
  645.     METHOD(void, write_jpeg_data, (compress_info_ptr cinfo,
  646.                        char *dataptr,
  647.                        int datacount));
  648.     METHOD(void, write_scan_trailer, (compress_info_ptr cinfo));
  649.     METHOD(void, write_file_trailer, (compress_info_ptr cinfo));
  650.     /* Pipeline control */
  651.     METHOD(void, c_pipeline_controller, (compress_info_ptr cinfo));
  652.     METHOD(void, entropy_output, (compress_info_ptr cinfo,
  653.                       char *dataptr,
  654.                       int datacount));
  655.     /* Overall control */
  656.     METHOD(void, c_per_scan_method_selection, (compress_info_ptr cinfo));
  657. };
  658.  
  659. /* Methods used during JPEG decompression. */
  660.  
  661. struct decompress_methods_struct {
  662.     /* Hook for user interface to get control after reading file header */
  663.     METHOD(void, d_ui_method_selection, (decompress_info_ptr cinfo));
  664.     /* JPEG file scanning */
  665.     /* Note: user interface supplies read_jpeg_data for JFIF/raw-JPEG
  666.      * reading.  For file formats that require random access (eg, TIFF)
  667.      * the JPEG file header module will override the UI read_jpeg_data.
  668.      */
  669.     METHOD(void, read_file_header, (decompress_info_ptr cinfo));
  670.     METHOD(boolean, read_scan_header, (decompress_info_ptr cinfo));
  671.     METHOD(int, read_jpeg_data, (decompress_info_ptr cinfo));
  672.     METHOD(void, read_scan_trailer, (decompress_info_ptr cinfo));
  673.     METHOD(void, read_file_trailer, (decompress_info_ptr cinfo));
  674.     /* Entropy decoding */
  675.     METHOD(void, entropy_decoder_init, (decompress_info_ptr cinfo));
  676.     METHOD(void, entropy_decode, (decompress_info_ptr cinfo,
  677.                       JBLOCK *MCU_data));
  678.     METHOD(void, entropy_decoder_term, (decompress_info_ptr cinfo));
  679.     /* MCU disassembly: fetch MCUs from entropy_decode, build coef array */
  680.     METHOD(void, disassemble_init, (decompress_info_ptr cinfo));
  681.     METHOD(void, disassemble_MCU, (decompress_info_ptr cinfo,
  682.                        JBLOCKIMAGE image_data));
  683.     METHOD(void, disassemble_term, (decompress_info_ptr cinfo));
  684.     /* Cross-block smoothing */
  685.     METHOD(void, smooth_coefficients, (decompress_info_ptr cinfo,
  686.                        jpeg_component_info *compptr,
  687.                        JBLOCKROW above,
  688.                        JBLOCKROW currow,
  689.                        JBLOCKROW below,
  690.                        JBLOCKROW output));
  691.     /* Un-subsample pixel values of a single component */
  692.     /* There can be a different unsubsample method for each component */
  693.     METHOD(void, unsubsample_init, (decompress_info_ptr cinfo));
  694.     unsubsample_ptr unsubsample[MAX_COMPS_IN_SCAN];
  695.     METHOD(void, unsubsample_term, (decompress_info_ptr cinfo));
  696.     /* Gamma and color space conversion */
  697.     METHOD(void, colorout_init, (decompress_info_ptr cinfo));
  698.     METHOD(void, color_convert, (decompress_info_ptr cinfo,
  699.                      int num_rows,
  700.                      JSAMPIMAGE input_data,
  701.                      JSAMPIMAGE output_data));
  702.     METHOD(void, colorout_term, (decompress_info_ptr cinfo));
  703.     /* Color quantization */
  704.     METHOD(void, color_quant_init, (decompress_info_ptr cinfo));
  705.     METHOD(void, color_quantize, (decompress_info_ptr cinfo,
  706.                       int num_rows,
  707.                       JSAMPIMAGE input_data,
  708.                       JSAMPARRAY output_data));
  709.     METHOD(void, color_quant_prescan, (decompress_info_ptr cinfo,
  710.                        int num_rows,
  711.                        JSAMPIMAGE image_data));
  712.     METHOD(void, color_quant_doit, (decompress_info_ptr cinfo,
  713.                     quantize_caller_ptr source_method));
  714.     METHOD(void, color_quant_term, (decompress_info_ptr cinfo));
  715.     /* Output image writing */
  716.     METHOD(void, output_init, (decompress_info_ptr cinfo));
  717.     METHOD(void, put_color_map, (decompress_info_ptr cinfo,
  718.                      int num_colors, JSAMPARRAY colormap));
  719.     METHOD(void, put_pixel_rows, (decompress_info_ptr cinfo,
  720.                       int num_rows,
  721.                       JSAMPIMAGE pixel_data));
  722.     METHOD(void, output_term, (decompress_info_ptr cinfo));
  723.     /* Pipeline control */
  724.     METHOD(void, d_pipeline_controller, (decompress_info_ptr cinfo));
  725.     /* Overall control */
  726.     METHOD(void, d_per_scan_method_selection, (decompress_info_ptr cinfo));
  727. };
  728.  
  729.  
  730. /* External declarations for routines that aren't called via method ptrs. */
  731. /* Note: use "j" as first char of names to minimize namespace pollution. */
  732. /* The PP macro hides prototype parameters from compilers that can't cope. */
  733.  
  734. #ifdef PROTO
  735. #define PP(arglist)    arglist
  736. #else
  737. #define PP(arglist)    ()
  738. #endif
  739.  
  740.  
  741. /* main entry for compression */
  742. EXTERN void jpeg_compress PP((compress_info_ptr cinfo));
  743. /* default parameter setup for compression */
  744. EXTERN void j_default_compression PP((compress_info_ptr cinfo, int quality));
  745. EXTERN void j_monochrome_default PP((compress_info_ptr cinfo));
  746. EXTERN void j_set_quality PP((compress_info_ptr cinfo, int quality,
  747.                   boolean force_baseline));
  748. EXTERN void j_free_defaults PP((compress_info_ptr cinfo));
  749.  
  750. /* main entry for decompression */
  751. EXTERN void jpeg_decompress PP((decompress_info_ptr cinfo));
  752.  
  753. /* forward DCT */
  754. EXTERN void j_fwd_dct PP((DCTBLOCK data));
  755. /* inverse DCT */
  756. EXTERN void j_rev_dct PP((DCTBLOCK data));
  757.  
  758. /* utility routines in jutils.c */
  759. EXTERN long jround_up PP((long a, long b));
  760. EXTERN void jcopy_sample_rows PP((JSAMPARRAY input_array, int source_row,
  761.                   JSAMPARRAY output_array, int dest_row,
  762.                   int num_rows, long num_cols));
  763. EXTERN void jcopy_block_row PP((JBLOCKROW input_row, JBLOCKROW output_row,
  764.                 long num_blocks));
  765. EXTERN void jzero_far PP((void FAR * target, size_t bytestozero));
  766.  
  767. /* method selection routines for compression modules */
  768. EXTERN void jselcpipeline PP((compress_info_ptr cinfo)); /* jcpipe.c */
  769. EXTERN void jselchuffman PP((compress_info_ptr cinfo)); /* jchuff.c */
  770. EXTERN void jselcarithmetic PP((compress_info_ptr cinfo)); /* jcarith.c */
  771. EXTERN void jselexpand PP((compress_info_ptr cinfo)); /* jcexpand.c */
  772. EXTERN void jselsubsample PP((compress_info_ptr cinfo)); /* jcsample.c */
  773. EXTERN void jselcmcu PP((compress_info_ptr cinfo)); /* jcmcu.c */
  774. EXTERN void jselccolor PP((compress_info_ptr cinfo));    /* jccolor.c */
  775. /* The user interface should call one of these to select input format: */
  776. EXTERN void jselrgif PP((compress_info_ptr cinfo)); /* jrdgif.c */
  777. EXTERN void jselrppm PP((compress_info_ptr cinfo)); /* jrdppm.c */
  778. /* and one of these to select output header format: */
  779. EXTERN void jselwjfif PP((compress_info_ptr cinfo)); /* jwrjfif.c */
  780.  
  781. /* method selection routines for decompression modules */
  782. EXTERN void jseldpipeline PP((decompress_info_ptr cinfo)); /* jdpipe.c */
  783. EXTERN void jseldhuffman PP((decompress_info_ptr cinfo)); /* jdhuff.c */
  784. EXTERN void jseldarithmetic PP((decompress_info_ptr cinfo)); /* jdarith.c */
  785. EXTERN void jseldmcu PP((decompress_info_ptr cinfo)); /* jdmcu.c */
  786. EXTERN void jselbsmooth PP((decompress_info_ptr cinfo)); /* jbsmooth.c */
  787. EXTERN void jselunsubsample PP((decompress_info_ptr cinfo)); /* jdsample.c */
  788. EXTERN void jseldcolor PP((decompress_info_ptr cinfo));    /* jdcolor.c */
  789. EXTERN void jsel1quantize PP((decompress_info_ptr cinfo)); /* jquant1.c */
  790. EXTERN void jsel2quantize PP((decompress_info_ptr cinfo)); /* jquant2.c */
  791. /* The user interface should call one of these to select input format: */
  792. EXTERN void jselrjfif PP((decompress_info_ptr cinfo)); /* jrdjfif.c */
  793. /* and one of these to select output image format: */
  794. EXTERN void jselwgif PP((decompress_info_ptr cinfo)); /* jwrgif.c */
  795. EXTERN void jselwppm PP((decompress_info_ptr cinfo)); /* jwrppm.c */
  796.  
  797. /* method selection routines for system-dependent modules */
  798. EXTERN void jselerror PP((external_methods_ptr emethods)); /* jerror.c */
  799. EXTERN void jselvirtmem PP((external_methods_ptr emethods)); /* jvirtmem.c */
  800.  
  801. /* debugging hook in jvirtmem.c */
  802. #ifdef MEM_STATS
  803. EXTERN void j_mem_stats PP((void));
  804. #endif
  805.  
  806. /* Miscellaneous useful macros */
  807.  
  808. #define MAX(a,b)    ((a) > (b) ? (a) : (b))
  809. #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  810.  
  811.  
  812. #define RST0    0xD0        /* RST0 marker code */
  813.